Assets/Scripts/Imported/Tilemap/Tiles/Rule Override Tile/Scripts/RuleOverrideTile.cs

   1 using System;
   2 using System.Collections.Generic;
   3 using System.Linq;
   4 using UnityEngine.Tilemaps;
   5
   6 namespace UnityEngine
   7 {
   8         [Serializable]
   9         [CreateAssetMenu]
  10         public class RuleOverrideTile : TileBase
  11         {
  12                 [Serializable]
  13                 public class TileSpritePair
  14                 {
  15                         public Sprite m_OriginalSprite;
  16                         public Sprite m_OverrideSprite;
  17                 }
  18                 [Serializable]
  19                 public class OverrideTilingRule
  20                 {
  21                         public bool m_Enabled;
  22                         public RuleTile.TilingRule m_TilingRule = new RuleTile.TilingRule();
  23                 }
  24
  25                 public Sprite this[Sprite originalSprite]
  26                 {
  27                         get
  28                         {
  29                                 foreach (TileSpritePair spritePair in m_Sprites)
  30                                 {
  31                                         if (spritePair.m_OriginalSprite == originalSprite)
  32                                         {
  33                                                 return spritePair.m_OverrideSprite;
  34                                         }
  35                                 }
  36                                 return null;
  37                         }
  38                         set
  39                         {
  40                                 if (value == null)
  41                                 {
  42                                         m_Sprites = m_Sprites.Where(spritePair => spritePair.m_OriginalSprite != originalSprite).ToList();
  43                                 }
  44                                 else
  45                                 {
  46                                         foreach (TileSpritePair spritePair in m_Sprites)
  47                                         {
  48                                                 if (spritePair.m_OriginalSprite == originalSprite)
  49                                                 {
  50                                                         spritePair.m_OverrideSprite = value;
  51                                                         return;
  52                                                 }
  53                                         }
  54                                         m_Sprites.Add(new TileSpritePair()
  55                                         {
  56                                                 m_OriginalSprite = originalSprite,
  57                                                 m_OverrideSprite = value,
  58                                         });
  59                                 }
  60                         }
  61                 }
  62                 public RuleTile.TilingRule this[RuleTile.TilingRule originalRule]
  63                 {
  64                         get
  65                         {
  66                                 if (!m_Tile)
  67                                         return null;
  68
  69                                 int index = m_Tile.m_TilingRules.IndexOf(originalRule);
  70                                 if (index == -1)
  71                                         return null;
  72                                 if (m_OverrideTilingRules.Count < index + 1)
  73                                         return null;
  74
  75                                 return m_OverrideTilingRules[index].m_Enabled ? m_OverrideTilingRules[index].m_TilingRule : null;
  76                         }
  77                         set
  78                         {
  79                                 if (!m_Tile)
  80                                         return;
  81
  82                                 int index = m_Tile.m_TilingRules.IndexOf(originalRule);
  83                                 if (index == -1)
  84                                         return;
  85
  86                                 if (value == null)
  87                                 {
  88                                         if (m_OverrideTilingRules.Count < index + 1)
  89                                                 return;
  90                                         m_OverrideTilingRules[index].m_Enabled = false;
  91                                         while (m_OverrideTilingRules.Count > 0 && !m_OverrideTilingRules[m_OverrideTilingRules.Count - 1].m_Enabled)
  92                                                 m_OverrideTilingRules.RemoveAt(m_OverrideTilingRules.Count - 1);
  93                                 }
  94                                 else
  95                                 {
  96                                         while (m_OverrideTilingRules.Count < index + 1)
  97                                                 m_OverrideTilingRules.Add(new OverrideTilingRule());
  98                                         m_OverrideTilingRules[index].m_Enabled = true;
  99                                         m_OverrideTilingRules[index].m_TilingRule = CloneTilingRule(value);
 100                                         m_OverrideTilingRules[index].m_TilingRule.m_Neighbors = null;
 101                                 }
 102                         }
 103                 }
 104
 105                 public RuleTile m_Tile;
 106                 public bool m_Advanced;
 107                 public List<TileSpritePair> m_Sprites = new List<TileSpritePair>();
 108                 public List<OverrideTilingRule> m_OverrideTilingRules = new List<OverrideTilingRule>();
 109                 public OverrideTilingRule m_OverrideDefault = new OverrideTilingRule();
 110                 public RuleTile.TilingRule m_OriginalDefault
 111                 {
 112                         get
 113                         {
 114                                 return new RuleTile.TilingRule()
 115                                 {
 116                                         m_Sprites = new Sprite[] { m_Tile != null ? m_Tile.m_DefaultSprite : null },
 117                                         m_ColliderType = m_Tile != null ? m_Tile.m_DefaultColliderType : Tile.ColliderType.None,
 118                                 };
 119                         }
 120                 }
 121
 122                 private RuleTile m_RuntimeTile;
 123
 124                 public override bool GetTileAnimationData(Vector3Int position, ITilemap tilemap, ref TileAnimationData tileAnimationData)
 125                 {
 126                         if (!m_RuntimeTile)
 127                                 Override();
 128                         return m_RuntimeTile.GetTileAnimationData(position, tilemap, ref tileAnimationData);
 129                 }
 130                 public override void GetTileData(Vector3Int position, ITilemap tilemap, ref TileData tileData)
 131                 {
 132                         if (!m_RuntimeTile)
 133                                 Override();
 134                         m_RuntimeTile.GetTileData(position, tilemap, ref tileData);
 135                 }
 136                 public override void RefreshTile(Vector3Int position, ITilemap tilemap)
 137                 {
 138                         if (!m_RuntimeTile)
 139                                 Override();
 140                         m_RuntimeTile.RefreshTile(position, tilemap);
 141                 }
 142                 public override bool StartUp(Vector3Int position, ITilemap tilemap, GameObject go)
 143                 {
 144                         Override();
 145                         return m_RuntimeTile.StartUp(position, tilemap, go);
 146                 }
 147
 148                 public void ApplyOverrides(IList<KeyValuePair<Sprite, Sprite>> overrides)
 149                 {
 150                         if (overrides == null)
 151                                 throw new System.ArgumentNullException("overrides");
 152
 153                         for (int i = 0; i < overrides.Count; i++)
 154                                 this[overrides[i].Key] = overrides[i].Value;
 155                 }
 156                 public void GetOverrides(List<KeyValuePair<Sprite, Sprite>> overrides)
 157                 {
 158                         if (overrides == null)
 159                                 throw new System.ArgumentNullException("overrides");
 160
 161                         overrides.Clear();
 162
 163                         if (!m_Tile)
 164                                 return;
 165
 166                         List<Sprite> originalSprites = new List<Sprite>();
 167
 168                         if (m_Tile.m_DefaultSprite)
 169                                 originalSprites.Add(m_Tile.m_DefaultSprite);
 170
 171                         foreach (RuleTile.TilingRule rule in m_Tile.m_TilingRules)
 172                                 foreach (Sprite sprite in rule.m_Sprites)
 173                                         if (sprite && !originalSprites.Contains(sprite))
 174                                                 originalSprites.Add(sprite);
 175
 176                         foreach (Sprite sprite in originalSprites)
 177                                 overrides.Add(new KeyValuePair<Sprite, Sprite>(sprite, this[sprite]));
 178                 }
 179                 public void ApplyOverrides(IList<KeyValuePair<RuleTile.TilingRule, RuleTile.TilingRule>> overrides)
 180                 {
 181                         if (overrides == null)
 182                                 throw new System.ArgumentNullException("overrides");
 183
 184                         for (int i = 0; i < overrides.Count; i++)
 185                                 this[overrides[i].Key] = overrides[i].Value;
 186                 }
 187                 public void GetOverrides(List<KeyValuePair<RuleTile.TilingRule, RuleTile.TilingRule>> overrides)
 188                 {
 189                         if (overrides == null)
 190                                 throw new System.ArgumentNullException("overrides");
 191
 192                         overrides.Clear();
 193
 194                         if (!m_Tile)
 195                                 return;
 196
 197                         foreach (var originalRule in m_Tile.m_TilingRules)
 198                         {
 199                                 RuleTile.TilingRule overrideRule = this[originalRule];
 200                                 overrides.Add(new KeyValuePair<RuleTile.TilingRule, RuleTile.TilingRule>(originalRule, overrideRule));
 201                         }
 202                         overrides.Add(new KeyValuePair<RuleTile.TilingRule, RuleTile.TilingRule>(m_OriginalDefault, m_OverrideDefault.m_TilingRule));
 203                 }
 204
 205                 public void Override()
 206                 {
 207                         m_RuntimeTile = m_Tile ? Instantiate(m_Tile) : new RuleTile();
 208                         m_RuntimeTile.m_Self = this;
 209                         if (!m_Advanced)
 210                         {
 211                                 if (m_RuntimeTile.m_DefaultSprite)
 212                                         m_RuntimeTile.m_DefaultSprite = this[m_RuntimeTile.m_DefaultSprite];
 213                                 if (m_RuntimeTile.m_TilingRules != null)
 214                                         foreach (RuleTile.TilingRule rule in m_RuntimeTile.m_TilingRules)
 215                                                 for (int i = 0; i < rule.m_Sprites.Length; i++)
 216                                                         if (rule.m_Sprites[i])
 217                                                                 rule.m_Sprites[i] = this[rule.m_Sprites[i]];
 218                         }
 219                         else
 220                         {
 221                                 if (m_OverrideDefault.m_Enabled)
 222                                 {
 223                                         m_RuntimeTile.m_DefaultSprite = m_OverrideDefault.m_TilingRule.m_Sprites.Length > 0 ? m_OverrideDefault.m_TilingRule.m_Sprites[0] : null;
 224                                         m_RuntimeTile.m_DefaultColliderType = m_OverrideDefault.m_TilingRule.m_ColliderType;
 225                                 }
 226                                 if (m_RuntimeTile.m_TilingRules != null) {
 227                                         for (int i = 0; i < m_RuntimeTile.m_TilingRules.Count; i++)
 228                                         {
 229                                                 RuleTile.TilingRule originalRule = m_RuntimeTile.m_TilingRules[i];
 230                                                 RuleTile.TilingRule overrideRule = this[m_Tile.m_TilingRules[i]];
 231                                                 if (overrideRule == null)
 232                                                         continue;
 233                                                 CopyTilingRule(overrideRule, originalRule, false);
 234                                         }
 235                                 }
 236                         }
 237                 }
 238                 public RuleTile.TilingRule CloneTilingRule(RuleTile.TilingRule from)
 239                 {
 240                         var clone = new RuleTile.TilingRule();
 241                         CopyTilingRule(from, clone, true);
 242                         return clone;
 243                 }
 244                 public void CopyTilingRule(RuleTile.TilingRule from, RuleTile.TilingRule to, bool copyRule)
 245                 {
 246                         if (copyRule)
 247                         {
 248                                 to.m_Neighbors = from.m_Neighbors;
 249                                 to.m_RuleTransform = from.m_RuleTransform;
 250                         }
 251                         to.m_Sprites = from.m_Sprites.Clone() as Sprite[];
 252                         to.m_AnimationSpeed = from.m_AnimationSpeed;
 253                         to.m_PerlinScale = from.m_PerlinScale;
 254                         to.m_Output = from.m_Output;
 255                         to.m_ColliderType = from.m_ColliderType;
 256                         to.m_RandomTransform = from.m_RandomTransform;
 257                 }
 258         }
 259 }